<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>

<script>
	
	// js 的组成 -> 浏览器端
	// ECMAScript -> js语法规范
	// DOM -> 文档对象模型
	// BOM -> 浏览器对象模型
	// h5 -> html5 css3 关于JS的功能
	
	// JS 在浏览器端的使用方式
	// 将 JS 代码写到 script 标签中
	// 引入 JS 文件
	// 注意：如果 script 标签写了 src 属性，那么就不要在这个 script 标签中写任何的 JS 代码，因为写了白写不会执行
	// 除了 head 里面的 title 标签中不能放 script 标签，html 页面的其他位置都可以放 script 标签
	
	// 变量 -> 表示一个可以改变可以参加运算的值
	// 变量的声明
	// 1、语法规范 var 表示要声明一个变量
	// 2、需要注意的事项
	// a, 变量命名时不能使用 关键字，保留字，
	// b, 不能以数字开头
	// c, 变量中不能出现 -
	// 什么是关键字，什么是保留字
	// 关键字 -> 指的是有具体的语法功能的单词或词组
	// 保留字 -> 就是准备用来做关键字，但是还没有给他赋予功能的单词或词组
	// 遵循驼峰命名法 -> 约定俗成
	// 1、尽力使用语义化的单词或词组
	// 2、如果是词组，第一个单词的首字母小写，从第二个单词开始所有单词的首字母均需要大写
	// 在JS语法中也使用了驼峰命名法的相关内容, 注意有两个地方是不遵循驼峰命名法的
	// 1、事件类型,全部都是小写
	// 2、构造函数 -> 用来构建对象的函数 -> 首字母大写
	// 补充：有两个单词在当作变量使用的时候需要注意 name  top
	// name 可以使用但是要小心，因为这个变量会天然挂在 window 对象下
	// top 不要使用这个单词做为变量名了，因为 top 会指向最高级的 window
	
	// 运算符 + 表达式
	// 运算符 -> 操作数据进行运算的符号
	// 从操作数据个数上分： 一元运算符， 二元运算符， 三元运算符
	// 从功能上分：算术运算符，比较运算符，逻辑运算符，赋值运算符，位运算符，自增运算符
	// 表达式 -> 变量和运算符组成的式子
	
	// 算术运算符
	// + - * / %
	// % -> 进行除法运算以后剩余不能整除的数
	// 注意：1, + 除了能够做加法运算，还能做拼接字符串的运算
	//      2, 尽量不要使用小数做数学运算, 因为小数都是近似数。0.1+0.2
	
	// 比较运算符
	// > < >= <= == === != !==  会给我一个布尔值，表示这个式子是否满足条件
	// > >= < <= 和数学中的用法是一毛一样的
	// ==  比较左右两边的值是否相等，如果左右两边的数据类型不一样会先转换然后再比较，简单说就是只看值是否一致，不考虑数据类型
	// === 全等，全部都相等，左右两边的值要相等，左右两边的数据类型要一直
	// != 是 == 的否定形式
	// !== 是 === 的否定形式
	// 不能做连续比较 5 > a > 3 => 5 > a && a > 3
	
	// 逻辑运算符 -> 和布尔值关系最密切
	// &&  ||  !
	// ! 非 表示取反 ，一定会得到一个布尔值
	// && 与 表示左右两边都满足条件那么整个式子才会为真
	// 全真为真，否则为假
	// 短路操作 当前面的式子能决定整个表达式的真假，那么后面的式子就不再计算
	// 表达式的值 左右两边哪个式子能决定这个表达式的真假，哪个式子的值就是这个表达式的值
	// || 或运算
	// 全假为假，否则为真
	// 短路操作 当前面的式子能确定整个表达式的真假，那么后面的式子就不再计算
	// 表达式的值 左右两边哪个式子能决定这个表达式的真假，哪个式子的值就是这个表达式的值
	
	// 赋值运算符 -> 右边的计算结果赋给左边的变量
	
	// 自增运算符 ++ --
	//  ++ 自增1  -- 自减1
	//  a++ ++a 这两个的值就是 a 的值，
	//  但是 a++ 表达式的值是 自增以前的 a 的值
	//  ++a 表达式的值 自增以后 a 的值
	//  +在前现自增再运算，+在后先运算再自增
	// 说明 -- 道理一样只不过自减
	// 运算指的是 这个表达式的值参与其他的计算
	
	// += -= *= -> a += 5; => a = a + 5; 累加
	
	// ^ ~
	// ^ 异或 可以用来交换两个变量的值
	// ~~ 可以对数字进行取整处理
	
	// 基本型数据类型
	// number
	// NaN -> not a number
	// Infinity -> 无穷
	// var a = 3e10;  科学计数法
	// var b = 0x0005; 十六进制写法
	// 如何判断是不是 NaN 使用 isNaN()
	
	// string
	// 1、成对出现的引号，引号引住的内容都叫字符串
	// 2、 '' 一对引号中间啥也没有 我们叫空字符串
	// 3、 '    ' 这个是以空格为字符的字符串不能称之为空字符串
	// boolean
	// true false
	
	// 1、如何判断基本型数据类型 我们可以使用 typeof
	// typeof 'abc'
	// typeof('abc');
	// 2、typeof 可以判断哪些数据类型，能准确判断哪些数据类型
	// 能判断六种数据类型 number string boolean function undefined object
	// 除了 object 这个类型以外都可以准确判断
	// 3、万能判断数据类型的方法 Object.prototype.toString.call()
	
	// 基本型数据类型的转换
	// number -> string
	// 强制转换 -> 我的这一句代码啥也不干就是为了转数据类型
	// var result = String(3);
	
	// 隐式转换 -> 在某种过程中不知不觉的将数据类型做转换
	// var result = 3 + '';
	
	// number -> boolean
	// 强制转换
	// var bool = Boolean(NaN);
	// console.log(bool);
	// console.log(typeof bool)
	// 隐式转换
	//     var a = 3;
	//     console.log(!!a);
	
	// string -> number
	// 强制转换
	//     Number('abc');
	// 隐式转换
	//     var a = '345';
	//     console.log(a - 0);
	
	// string -> boolean
	// 强制转换 -> 只有 '' 会转成 false
	// 隐式转换 -> !!string
	
	// boolean -> number
	// 强制  Number();
	// 隐式   让 boolean 参加数学运算
	// boolean -> string
	// String()
	//  boolean + '';
	
	// 总结：
	// 1、强制转换，用目标数据类型的内置构造函数
	// 2、隐式转换
	// 2、隐式转换
	// -> string  + '';
	// -> number 让他参加数学运算(加法除外)
	// -> boolean  !!a
	// 注意： 如无特殊需求，尽量保证转换前后的值不发送变化
	// 3、什么 样的数据可以转成 true , 什么样的数据可以转成 false
	// number中 0  NaN 可以转成 false
	// string 中 '' 可以转成false
	// 除此之外 undefined null 也会转成 false
	// 4、true or false 转成number 会是什么样子
	// true 转成1
	// false 转成0
	
	
	// 语句
	// if for for-in while do-while switch-case break
	// if 语句 表示判断，判断条件是否成立，成立.... , 不成立.....
	
	// if (表达式) {}
	// if ( 表达式 ) {} else {}
	// if (表达式) {} else if (表达式1) {} else if (表达式2) {}.....
	
	// 三元表达式
	// var result = 表达式1 ？ 表达式2 : 表达式3;
	// 当表达式1 为 true, 执行表达式2，当表达式1 为false的时候执行表达式3
	// 当表达式1为true 表达式2 的值就是整个三元表达式的值
	// 当表达式1为 false 表达式3 的值就是整个表达式 的值
	
	// 将百分制换算成等级制
	// 100 >= fenshu >= 90 -> A
	// 90 > fenshu >= 80 -> B
	// 80 > fenshu >= 70 -> C
	// 70 > fenshu >= 60 -> D
	// 60 > fenshu -> E
	// var num = prompt('adjd')
	// if (num >= 90) {
	// 	console.log('A')
	// } else if (num >= 80) {
	// 	console.log('B')
	// } else if (num >= 70) {
	// 	console.log('c')
	// } else if (num >= 60) {
	// 	console.log('D')
	// } else {
	// 	console.log('E')
	// }
    
    // for 循环语句
    // 语法
    // for ( 循环变量 ; 循环条件 ; 循环增量 ) {
    // 	// 循环体代码
    // }
    
    // 过程
    // 1、现执行循环变量
    // 2、判断循环条件是否为true
            // true , 执行一次循环体代码
            // 执行循环增量
            // 判断循环条件是否为true
            
            // false, 循环结束
    
    // 注意： 循环条件恒为true 会造成死循环，这样子会引起硬件设施的高速运算，温度会升高
    // 所有我们要尽量避免 死循环 -> 就是让循环条件 在某种情况下 判断为 false
    
    
    // while ( 循环条件 ) {
    // 	// 循环体
    // }
    
    // var a = 1;
    //
    // while (a < 5) {
    // 	console.log(a);
    // 	a++;
    // }
    //
    // console.log('finished');
    
    // do-while 循环
    
    // do {
    // 	// 循环体代码
    // } while (循环条件)
    
    
    // do-while 循环 首先会执行一次循环体代码
    
    // var a = 3;
    //
    // do {
    // 	a++;
    // 	console.log(a);
    // } while ( a < 10);
    
    
    // do-while 循环 和 while 循环 区别就在于 do-while 循环 无论循环条件是否成立都会先执行一次循环体代码
    
    
    // switch-case 语句
    
    // 小括号里是一个确切的值，这个值用来和 大括号中 case 后面的 值 做 == 比较
    // 如果 == 成立 就执行 这个case : 后面的代码
    // 如果 == 不成立（所有的case都比过了 没有一个是成立的），
        // 如果 switch 语句中 有 default 那么就执行 default 后面的代码
        // 如果 switch 语句中没有 default 那么就什么都不做 switch 语句结束
    
    // var value = prompt()
    // switch (value) {
    // 	case 'A':
    // 		console.log(1);
    // 		break;
    //     case 'B':
    //     	console.log(2);
    //     	break;
    //     case 'C':
    //     	console.log(3);
    //     	break;
    //     default:
    //     	console.log('default');
    // }
    
    // 注意：小括号中是一个具体的 值
    //     case 后面也是一个具体的值
	
	
	// 将百分制换算成等级制
	// 100 >= fenshu >= 90 -> A 99.9999999999999999999999    90     9
	// 90 > fenshu >= 80 -> B 89.999999999999999999999999    80     8
	// 80 > fenshu >= 70 -> C 79.999999999999999999999999    70     7
	// 70 > fenshu >= 60 -> D 69.999999999999999999999999    60     6
	// 60 > fenshu -> E
    
    // prompt(); parseInt();、











	var score = prompt('请输入数字');
	var sco = parseInt(score / 10);

	switch (sco) {
		case 10:
		case 9:
			console.log('A');
			break;
		case 8:
			console.log('B');
			break;
		case 7:
			console.log('C');
			break;
		case 6:
			console.log('D');
			break;
        default:
        	console.log('E');
	}
    
    // break -> 破坏，破坏语句，终止(跳出)语句的执行
    // continue 终止 本次循环执行下一次循环
    
    // for (var i = 0; true; i++) {
    // 	if (i == 100) {
    // 		console.log(i);
    // 		break;
    //     } else if (i % 2 == 0) {
    // 		continue;
    // 		console.log(i);
    //     } else {
    // 		console.log(i)
    //     }
    // }
    //
    // console.log('finished');

    
    // for 已知循环次数的场合
    // while 不知道循环多少次，想办法终止循环
    
    
    
    
    
    
    
    
    // 1、输出 1-100
    
    // for (var i = 1; i <= 100; i++) {
    // 	console.log(i);
    // }
    
    // 2、计算 1-100 所有数的和
    // var sum = 0;
    // for (var i = 1; i <= 100; i++)　{
    // 	sum += i;
    // }
    
    
    // 3、计算 1-100 所有能被3整除的数的和
    // var sum = 0;
    //
    // for (var i = 1; i <= 100; i++) {
    // 	if (i % 3 == 0) {
    // 		sum += i;
    //     }
    // }
    //
    // console.log(sum);
    
    
    // 4、使用 * 来输出一个正方形
    //     for(var i=1;i<4;i++){
    //     	for(var j=1;j<6;j++){
    //     		document.write('*')
    //         }
    //     	document.write('<br>')
    //     }
    
    // 5、使用 * 来输出一个 三角形
	// for(var i=1;i<5;i++){
	// 	for(var j=1;j<=(1+i);j++){
	// 		document.write('*')
	// 	}
	// 	document.write('<br>')
	// }
    
    // 6、使用 * 来输出一个 倒三角形
    
    // for (var a = 4; a > 0; a--) {
    // 	for (var b = 1; b <= a; b++ ) {
    // 		document.write('*  ');
    //     }
    // 	document.write('<br>');
    // }
    //
	//
	// for(var i=1;i<5;i++){
	// 	for(var j=1;j<(6-i);j++){
	// 		document.write('*')
	// 	}
	// 	document.write('<br>')
	// }
    // 7、在页面中输出 9*9 乘法口诀表

	// for(var i=1;i<=9;i++){
	// 	for(var j=1;j<=i;j++){
	// 		document.write(j+'*'+i+'='+(i*j)+'&nbsp&nbsp&nbsp')
	// 		// document.write('*')
	// 	}
	// 	document.write('<br>')
	// }
    
    // 8、使用 for 循环 和 * 在页面中输出 一个正三角形
    // 9、9 * 9 乘法口诀表，制作成有格式的样子
    
    // 提示： 在页面中输出内容 我们用的语法  document.write();
    
    
    
    
    

</script>

</body>
</html>
